/*
 * Copyright(c)2020-2021, 犯二青年博客
 * Author:liangguifeng
 */

/*
    Validator v1.1.0
    (c) Yair Even Or
    https://github.com/yairEO/validator

    MIT-style license.
*/

var validator = (function ($) {
    var message, tests, checkField, validate, mark, unmark, field, minmax, defaults,
        validateWords, lengthRange, lengthLimit, pattern, alertTxt, data,
        email_illegalChars = /[\(\)\<\>\,\;\:\\\/\"\[\]]/,
        email_filter = /^.+@.+\..{2,6}$/;  // exmaple email "steve@s-i.photo"

    /* general text messages
    */
    message = {
        invalid: '无效的输入',
        checked: 'must be checked',
        empty: '必填项',
        min: '输入内容太短',
        max: '输入内容太长',
        number_min: '数字太小',
        number_max: '数字太大',
        url: '无效的URL',
        number: '必须为数字',
        email: '无效的邮箱',
        email_repeat: '邮箱不一致',
        password_repeat: '密码不一致',
        repeat: '不一致',
        complete: 'input is not complete',
        select: '必选项'
    };
    // message = {
    //     invalid         : 'invalid input',
    //     checked         : 'must be checked',
    //     empty           : 'please put something here',
    //     min             : 'input is too short',
    //     max             : 'input is too long',
    //     number_min      : 'too low',
    //     number_max      : 'too high',
    //     url             : 'invalid URL',
    //     number          : 'not a number',
    //     email           : 'email address is invalid',
    //     email_repeat    : 'emails do not match',
    //     password_repeat : 'passwords do not match',
    //     repeat          : 'no match',
    //     complete        : 'input is not complete',
    //     select          : 'Please select an option'
    // };
    if (!window.console) {
        console = {};
        console.log = console.warn = function () {
            return;
        }
    }

    // defaults
    defaults = {
        alerts: true,
        classes: {
            item: 'item',
            alert: 'alert',
            bad: 'bad'
        }
    };

    /* Tests for each type of field (including Select element)
    */
    tests = {
        sameAsPlaceholder: function (a) {
            return $.fn.placeholder && a.attr('placeholder') !== undefined && data.val == a.prop('placeholder');
        },
        hasValue: function (a) {
            if (!a) {
                alertTxt = message.empty;
                return false;
            }
            return true;
        },
        // 'linked' is a special test case for inputs which their values should be equal to each other (ex. confirm email or retype password)
        linked: function (a, b) {
            if (b != a) {
                // choose a specific message or a general one
                alertTxt = message[data.type + '_repeat'] || message.no_match;
                return false;
            }
            return true;
        },
        email: function (a) {
            if (!email_filter.test(a) || a.match(email_illegalChars)) {
                alertTxt = a ? message.email : message.empty;
                return false;
            }
            return true;
        },
        // a "skip" will skip some of the tests (needed for keydown validation)
        text: function (a, skip) {
            // make sure there are at least X number of words, each at least 2 chars long.
            // for example 'john F kenedy' should be at least 2 words and will pass validation
            if (validateWords) {
                var words = a.split(' ');
                // iterrate on all the words
                var wordsLength = function (len) {
                    for (var w = words.length; w--;)
                        if (words[w].length < len)
                            return false;
                    return true;
                };

                if (words.length < validateWords || !wordsLength(2)) {
                    alertTxt = message.complete;
                    return false;
                }
                return true;
            }
            if (!skip && lengthRange && a.length < lengthRange[0]) {
                alertTxt = message.min;
                return false;
            }

            // check if there is max length & field length is greater than the allowed
            if (lengthRange && lengthRange[1] && a.length > lengthRange[1]) {
                alertTxt = message.max;
                return false;
            }

            // check if the field's value should obey any length limits, and if so, make sure the length of the value is as specified
            if (lengthLimit && lengthLimit.length) {
                while (lengthLimit.length) {
                    if (lengthLimit.pop() == a.length) {
                        alertTxt = message.complete;
                        return false;
                    }
                }
            }

            if (pattern) {
                var regex, jsRegex;
                switch (pattern) {
                    case 'alphanumeric' :
                        regex = /^[a-zA-Z0-9]+$/i;
                        break;
                    case 'numeric' :
                        regex = /^[0-9]+$/i;
                        break;
                    case 'phone' :
                        regex = /^\+?([0-9]|[-|' '])+$/i;
                        break;
                    default :
                        regex = pattern;
                }
                try {
                    jsRegex = new RegExp(regex).test(a);
                    if (a && !jsRegex)
                        return false;
                } catch (err) {
                    console.log(err, field, 'regex is invalid');
                    return false;
                }
            }

            return true;
        },
        number: function (a) {
            // if not not a number
            if (isNaN(parseFloat(a)) && !isFinite(a)) {
                alertTxt = message.number;
                return false;
            }
            // not enough numbers
            else if (lengthRange && a.length < lengthRange[0]) {
                alertTxt = message.min;
                return false;
            }
            // check if there is max length & field length is greater than the allowed
            else if (lengthRange && lengthRange[1] && a.length > lengthRange[1]) {
                alertTxt = message.max;
                return false;
            } else if (minmax[0] && (a | 0) < minmax[0]) {
                alertTxt = message.number_min;
                return false;
            } else if (minmax[1] && (a | 0) > minmax[1]) {
                alertTxt = message.number_max;
                return false;
            }
            return true;
        },
        // Date is validated in European format (day,month,year)
        date: function (a) {
            var day, A = a.split(/[-./]/g), i;
            // if there is native HTML5 support:
            if (field[0].valueAsNumber)
                return true;

            for (i = A.length; i--;) {
                if (isNaN(parseFloat(a)) && !isFinite(a))
                    return false;
            }
            try {
                day = new Date(A[2], A[1] - 1, A[0]);
                if (day.getMonth() + 1 == A[1] && day.getDate() == A[0])
                    return day;
                return false;
            } catch (er) {
                console.log('date test: ', err);
                return false;
            }
        },
        url: function (a) {
            // minimalistic URL validation
            function testUrl(url) {
                return /^(https?:\/\/)?([\w\d\-_]+\.+[A-Za-z]{2,})+\/?/.test(url);
            }

            if (!testUrl(a)) {
                alertTxt = a ? message.url : message.empty;
                return false;
            }
            return true;
        },
        hidden: function (a) {
            if (lengthRange && a.length < lengthRange[0]) {
                alertTxt = message.min;
                return false;
            }
            if (pattern) {
                var regex;
                if (pattern == 'alphanumeric') {
                    regex = /^[a-z0-9]+$/i;
                    if (!regex.test(a)) {
                        return false;
                    }
                }
            }
            return true;
        },
        select: function (a) {
            if (!tests.hasValue(a)) {
                alertTxt = message.select;
                return false;
            }
            return true;
        }
    };

    /* marks invalid fields
    */
    mark = function (field, text) {
        if (!text || !field || !field.length)
            return false;

        // check if not already marked as a 'bad' record and add the 'alert' object.
        // if already is marked as 'bad', then make sure the text is set again because i might change depending on validation
        var item = field.closest('.' + defaults.classes.item),
            warning;

        if (item.hasClass(defaults.classes.bad)) {
            if (defaults.alerts)
                item.find('.' + defaults.classes.alert).html(text);
        } else if (defaults.alerts) {
            warning = $('<div class="' + defaults.classes.alert + '">').html(text);
            item.append(warning);
        }

        item.removeClass(defaults.classes.bad);
        // a delay so the "alert" could be transitioned via CSS
        setTimeout(function () {
            item.addClass(defaults.classes.bad);
        }, 0);
    };
    /* un-marks invalid fields
    */
    unmark = function (field) {
        if (!field || !field.length) {
            console.warn('no "field" argument, null or DOM object not found');
            return false;
        }

        field.closest('.' + defaults.classes.item)
            .removeClass(defaults.classes.bad)
            .find('.' + defaults.classes.alert).remove();
    };

    function testByType(type, value) {
        if (type == 'tel')
            pattern = pattern || 'phone';

        if (!type || type == 'password' || type == 'tel' || type == 'search' || type == 'file')
            type = 'text';


        return tests[type] ? tests[type](value, true) : true;
    }

    function prepareFieldData(el) {
        field = $(el);

        field.data('valid', true);                // initialize validity of field
        field.data('type', field.attr('type'));   // every field starts as 'valid=true' until proven otherwise
        pattern = field.attr('pattern');
    }

    /* Validations per-character keypress
    */
    function keypress(e) {
        prepareFieldData(this);
        //  String.fromCharCode(e.charCode)

        if (e.charCode) {
            return testByType(this.type, this.value);
        }
    }

    /* Checks a single form field by it's type and specific (custom) attributes
    */
    function checkField() {
        // skip testing fields whom their type is not HIDDEN but they are HIDDEN via CSS.
        if (this.type != 'hidden' && $(this).is(':hidden'))
            return true;

        prepareFieldData(this);

        field.data('val', field[0].value.replace(/^\s+|\s+$/g, ""));  // cache the value of the field and trim it
        data = field.data();

        // Check if there is a specific error message for that field, if not, use the default 'invalid' message
        alertTxt = message[field.prop('name')] || message.invalid;

        // Special treatment
        if (field[0].nodeName.toLowerCase() === "select") {
            data.type = 'select';
        } else if (field[0].nodeName.toLowerCase() === "textarea") {
            data.type = 'text';
        }
        /* Gather Custom data attributes for specific validation:
        */
        validateWords = data['validateWords'] || 0;
        lengthRange = data['validateLengthRange'] ? (data['validateLengthRange'] + '').split(',') : [1];
        lengthLimit = data['validateLength'] ? (data['validateLength'] + '').split(',') : false;
        minmax = data['validateMinmax'] ? (data['validateMinmax'] + '').split(',') : ''; // for type 'number', defines the minimum and/or maximum for the value as a number.

        data.valid = tests.hasValue(data.val);

        if (field.hasClass('optional') && !data.valid)
            data.valid = true;


        // for checkboxes
        if (field[0].type === "checkbox") {
            data.valid = field[0].checked;
            alertTxt = message.checked;
        }

        // check if field has any value
        else if (data.valid) {
            /* Validate the field's value is different than the placeholder attribute (and attribute exists)
            * this is needed when fixing the placeholders for older browsers which does not support them.
            * in this case, make sure the "placeholder" jQuery plugin was even used before proceeding
            */
            if (tests.sameAsPlaceholder(field)) {
                alertTxt = message.empty;
                data.valid = false;
            }

            // if this field is linked to another field (their values should be the same)
            if (data.validateLinked) {
                var linkedTo = data['validateLinked'].indexOf('#') == 0 ? $(data['validateLinked']) : $(':input[name=' + data['validateLinked'] + ']');
                data.valid = tests.linked(data.val, linkedTo.val());
            }
            /* validate by type of field. use 'attr()' is proffered to get the actual value and not what the browsers sees for unsupported types.
            */
            else if (data.valid || data.type == 'select')
                data.valid = testByType(data.type, data.val);

        }

        // mark / unmark the field, and set the general 'submit' flag accordingly
        if (data.valid)
            unmark(field);
        else {
            mark(field, alertTxt);
            submit = false;
        }

        return data.valid;
    }

    /* vaildates all the REQUIRED fields prior to submiting the form
    */
    function checkAll($form) {
        $form = $($form);

        if ($form.length == 0) {
            console.warn('element not found');
            return false;
        }

        var that = this,
            submit = true, // bindSaveInfoEvent the scope
            // get all the input/textareas/select fields which are required or optional (meaning, they need validation only if they were filled)
            fieldsToCheck = $form.find(':input').filter('[required=required], .required, .optional').not('[disabled=disabled]');

        fieldsToCheck.each(function () {
            // use an AND operation, so if any of the fields returns 'false' then the submitted result will be also FALSE
            submit = submit * checkField.apply(this);
        });

        return !!submit;  // casting the variable to make sure it's a boolean
    }

    return {
        defaults: defaults,
        checkField: checkField,
        keypress: keypress,
        checkAll: checkAll,
        mark: mark,
        unmark: unmark,
        message: message,
        tests: tests
    }
})(jQuery);